/**
 * 数据源管理器
 * 
 * 用途：统一管理蓝牙数据源
 * 方法：使用工厂模式创建数据源，提供统一的接口进行数据采集管理
 * 原理：封装数据源的初始化、连接、数据采集等操作，支持状态监听和错误处理
 */
package com.example.brain_wave.data

import com.example.brain_wave.ui.components.BrainWaveDataPoint
import com.example.brain_wave.ui.components.NeuroSkyRawDataPoint
import android.content.Context

/**
 * 数据源类型枚举
 */
enum class DataSourceType {
    BLUETOOTH   // 蓝牙数据源
}

/**
 * 数据源管理器
 * 负责创建和管理蓝牙数据源
 */
class DataSourceManager(private val context: Context) {
    
    private var currentDataSource: DataSourceInterface? = null
    private var currentSourceType: DataSourceType? = null
    
    // 回调函数
    private var onStateChanged: ((DataSourceState) -> Unit)? = null
    private var onDataPointGenerated: ((BrainWaveDataPoint) -> Unit)? = null
    private var onRawDataGenerated: ((NeuroSkyRawDataPoint) -> Unit)? = null
    private var onError: ((String) -> Unit)? = null

    /**
     * 创建指定类型的数据源
     */
    fun createDataSource(type: DataSourceType, config: Map<String, Any> = emptyMap()): Boolean {
        return try {
            println("🏭 创建数据源: $type")
            
            // 清理现有数据源
            cleanup()
            
            // 创建新数据源
            val dataSource = when (type) {
                DataSourceType.BLUETOOTH -> BluetoothDataSource(context)
            }
            
            // 设置回调
            dataSource.setOnStateChanged { state ->
                onStateChanged?.invoke(state)
            }
            
            dataSource.setOnDataPointGenerated { dataPoint ->
                onDataPointGenerated?.invoke(dataPoint)
            }
            
            // 设置原始数据生成回调（如果数据源支持）
            if (dataSource is BluetoothDataSource) {
                dataSource.setOnRawDataGenerated { rawData ->
                    onRawDataGenerated?.invoke(rawData)
                }
            }
            
            dataSource.setOnError { error ->
                onError?.invoke(error)
            }
            
            // 初始化数据源
            dataSource.initialize(config)
            
            currentDataSource = dataSource
            currentSourceType = type
            
            println("✅ 数据源创建成功: $type")
            true
            
        } catch (e: Exception) {
            println("❌ 数据源创建失败: ${e.message}")
            onError?.invoke("数据源创建失败: ${e.message}")
            false
        }
    }
    
    /**
     * 连接当前数据源
     */
    suspend fun connect(): Boolean {
        val dataSource = currentDataSource
        if (dataSource == null) {
            onError?.invoke("没有可用的数据源")
            return false
        }
        
        return try {
            println("🔗 连接数据源: $currentSourceType")
            dataSource.connect()
        } catch (e: Exception) {
            println("❌ 数据源连接失败: ${e.message}")
            onError?.invoke("数据源连接失败: ${e.message}")
            false
        }
    }
    
    /**
     * 断开当前数据源
     */
    suspend fun disconnect() {
        val dataSource = currentDataSource
        if (dataSource == null) {
            println("⚠️ 没有可断开的数据源")
            return
        }
        
        try {
            println("🔌 断开数据源: $currentSourceType")
            dataSource.disconnect()
        } catch (e: Exception) {
            println("❌ 数据源断开失败: ${e.message}")
            onError?.invoke("数据源断开失败: ${e.message}")
        }
    }
    
    /**
     * 开始数据采集
     */
    fun startDataCollection() {
        val dataSource = currentDataSource
        if (dataSource == null) {
            onError?.invoke("没有可用的数据源")
            return
        }
        
        if (!dataSource.isConnected()) {
            onError?.invoke("数据源未连接，无法开始采集")
            return
        }
        
        try {
            println("🚀 开始数据采集: $currentSourceType")
            dataSource.startDataCollection()
        } catch (e: Exception) {
            println("❌ 开始数据采集失败: ${e.message}")
            onError?.invoke("开始数据采集失败: ${e.message}")
        }
    }
    
    /**
     * 停止数据采集
     */
    fun stopDataCollection() {
        val dataSource = currentDataSource
        if (dataSource == null) {
            println("⚠️ 没有可停止的数据源")
            return
        }
        
        try {
            println("🛑 停止数据采集: $currentSourceType")
            dataSource.stopDataCollection()
        } catch (e: Exception) {
            println("❌ 停止数据采集失败: ${e.message}")
            onError?.invoke("停止数据采集失败: ${e.message}")
        }
    }
    
    /**
     * 获取当前数据源状态
     */
    fun getCurrentState(): DataSourceState? = currentDataSource?.getCurrentState()
    
    /**
     * 检查数据源是否已连接
     */
    fun isConnected(): Boolean = currentDataSource?.isConnected() ?: false
    
    /**
     * 检查是否正在采集数据
     */
    fun isCollecting(): Boolean = currentDataSource?.isCollecting() ?: false
    
    /**
     * 获取当前数据源类型
     */
    fun getCurrentSourceType(): DataSourceType? = currentSourceType
    
    /**
     * 设置状态变化回调
     */
    fun setOnStateChanged(callback: (DataSourceState) -> Unit) {
        onStateChanged = callback
    }
    
    /**
     * 设置数据点生成回调
     */
    fun setOnDataPointGenerated(callback: (BrainWaveDataPoint) -> Unit) {
        onDataPointGenerated = callback
    }
    
    /**
     * 设置原始数据生成回调
     * 用于将NeuroSky原始数据发送到分析服务端
     */
    fun setOnRawDataGenerated(callback: (NeuroSkyRawDataPoint) -> Unit) {
        onRawDataGenerated = callback
    }
    
    /**
     * 设置错误回调
     */
    fun setOnError(callback: (String) -> Unit) {
        onError = callback
    }
    
    /**
     * 清理资源
     */
    fun cleanup() {
        try {
            println("🧹 清理数据源管理器资源")
            
            currentDataSource?.cleanup()
            currentDataSource = null
            currentSourceType = null
            
            // 清理回调
            onStateChanged = null
            onDataPointGenerated = null
            onRawDataGenerated = null
            onError = null
            
            println("✅ 数据源管理器资源清理完成")
            
        } catch (e: Exception) {
            println("❌ 数据源管理器清理失败: ${e.message}")
        }
    }
}